/*
 * Powered By XY
 * Since 2020
 */

package com.xy.biz.base.manager;

import com.xy.biz.base.domain.bo.DictBO;
import com.xy.biz.base.domain.dto.DictPropertyDTO;
import com.xy.biz.base.domain.po.DictPO;
import com.xy.biz.base.domain.query.DictQuery;
import com.xy.biz.base.domain.req.GetDictByCodeRequest;
import com.xy.biz.base.domain.req.GetDictRequest;
import com.xy.biz.base.domain.req.ListDictItemRequest;
import com.xy.biz.base.domain.req.UpdateDictAllRequest;
import com.xy.biz.base.domain.resp.ListDictItemResponse;
import com.xy.lang.domain.StringKeyValue;
import com.xy.lang.domain.treeing.TreeItem;

import java.util.List;

/**
 *
 *
 * @author zsp
 * @date 2020-8-16
 */
public interface DictManager {

    /**
     * 保存
     *
     * @param dictBO
     */
    DictBO saveDict(DictBO dictBO);

    /**
     * 更新
     *
     * @param dictBO
     */
    int updateDictName(DictBO dictBO);

    /**
     * 更新
     *
     * @param dictBO
     */
    int updateDict(DictBO dictBO);

    /**
     * 删除
     *
     * @param dictId
     */
    int deleteDict(Long dictId);

    /**
     * 是否存在
     * @param dictId
     */
    boolean isDictExists(Long dictId);

    /**
     * 查找一个
     *
     * @param request
     * @return
     */
    DictBO getDict(GetDictRequest request);

    /**
     * 查找一个
     *
     * @param request
     * @return
     */
    ListDictItemResponse getDictItem(GetDictByCodeRequest request);

    /**
     * 查找多个
     *
     * @param query 查找条件
     */
    List<DictBO> listDict(DictQuery query);

    /**
     * 统计个数
     *
     * @param query 查找条件
     */
    int countDict(DictQuery query);

    /**
     *
     * @param request
     * @return
     */
    List<DictPropertyDTO> listDictProperty(GetDictRequest request);

    /**
     *
     * @param request
     * @return
     */
    List<DictPropertyDTO> listDictProperties(GetDictRequest request);

    /**
     * 根据分组编码查找字典
     *
     * @param request
     * @return
     */
    List<ListDictItemResponse> listDictItem(ListDictItemRequest request);

    /**
     *
     * @param dictId
     * @return
     */
    int getMaxPropertyKey(Long dictId);

    /**
     *
     * @param type
     * @return
     */
    List<StringKeyValue> listDictGroupItem(Integer type);

    /**
     *
     * @param dictId
     * @return
     */
    List<Long> listParentDictId(Long dictId);

    /**
     *
     * @param dictId
     * @return
     */
    List<Long> listChildrenDictId(Long dictId);


    /// default methods


    /**
     * 字典编码是否存在
     *
     * @param dictGroupCode
     * @param dictCode
     * @param tenantId
     * @return
     */
    default boolean isDictExists(String dictGroupCode, String dictCode, Long tenantId) {
        DictQuery dictQuery = DictQuery.one()
                .dictGroupCode(dictGroupCode)
                .dictCode(dictCode)
                .tenantId(tenantId)
                .build();
        return countDict(dictQuery) > 0;
    }

    /**
     * 字典值是否存在
     *
     * @param dictGroupCode
     * @param dictValue
     * @param tenantId
     * @return
     */
    default boolean isDictExists(Long tenantId, String dictGroupCode, String dictValue) {
        DictQuery dictQuery = DictQuery.one()
                .dictGroupCode(dictGroupCode)
                .dictValue(dictValue)
                .tenantId(tenantId)
                .build();
        return countDict(dictQuery) > 0;
    }

    /**
     * 孩子字典是否存在
     *
     * @param parentDictId
     * @return
     */
    default boolean isDictHasChildren(Long parentDictId) {
        DictQuery dictQuery = DictQuery.one()
                .parentDictId(parentDictId)
                .build();
        return countDict(dictQuery) > 0;
    }

    List<TreeItem> listDictGroupItemAll(Integer type);

    List<TreeItem> listDictGroupItemByGroupCode(ListDictItemRequest request);

    Integer updateAll(UpdateDictAllRequest request);
}
